home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Freeware / Miro 1.0 / Miro_Installer.exe / Miro_Downloader.exe / autodler.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-11-12  |  6.3 KB  |  211 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. import filters
  5. import views
  6. import config
  7. import prefs
  8. import eventloop
  9. import httpclient
  10. from clock import clock
  11. from datetime import datetime
  12. from fasttypes import SortedList
  13.  
  14. def manualPendingFilter(x):
  15.     """Returns true iff x is a manual download item that's pending"""
  16.     return x.isPendingManualDownload()
  17.  
  18.  
  19. def autoPendingFilter(x):
  20.     """Returns true iff x is an automatic download item that's pending"""
  21.     if not x.getFeed().isAutoDownloadable():
  22.         return False
  23.     
  24.     return x.isEligibleForAutoDownload()
  25.  
  26.  
  27. def pendingSort(a, b):
  28.     if a[1] < b[1]:
  29.         return True
  30.     
  31.     if a[1] > b[1]:
  32.         return False
  33.     
  34.     return a[2] < b[2]
  35.  
  36.  
  37. class Downloader:
  38.     
  39.     def __init__(self, is_auto):
  40.         self.dc = None
  41.         self.inDownloads = False
  42.         self.paused = False
  43.         self.running_count = 0
  44.         self.pending_count = 0
  45.         self.feed_pending_count = { }
  46.         self.feed_running_count = { }
  47.         self.feed_time = { }
  48.         self.is_auto = is_auto
  49.         if is_auto:
  50.             self.pendingItems = views.items.filter(autoPendingFilter)
  51.             self.runningItems = views.autoDownloads
  52.             self.MAX = config.get(prefs.DOWNLOADS_TARGET)
  53.         else:
  54.             self.pendingItems = views.items.filter(manualPendingFilter)
  55.             self.runningItems = views.manualDownloads
  56.             self.MAX = config.get(prefs.MAX_MANUAL_DOWNLOADS)
  57.         for item in self.pendingItems:
  58.             self.pendingOnAdd(item, item.id)
  59.         
  60.         for item in self.runningItems:
  61.             self.runningOnAdd(item, item.id)
  62.         
  63.         self.pendingItems.addAddCallback(self.pendingOnAdd)
  64.         self.pendingItems.addRemoveCallback(self.pendingOnRemove)
  65.         self.runningItems.addAddCallback(self.runningOnAdd)
  66.         self.runningItems.addRemoveCallback(self.runningOnRemove)
  67.         if is_auto:
  68.             self.new_count = 0
  69.             self.feed_new_count = { }
  70.             self.newItems = views.newlyDownloadedItems
  71.             for item in self.newItems:
  72.                 self.newOnAdd(item, item.id)
  73.             
  74.             self.newItems.addAddCallback(self.newOnAdd)
  75.             self.newItems.addRemoveCallback(self.newOnRemove)
  76.         
  77.  
  78.     
  79.     def updateMAX(self):
  80.         if self.is_auto:
  81.             newmax = config.get(prefs.DOWNLOADS_TARGET)
  82.         else:
  83.             newmax = config.get(prefs.MAX_MANUAL_DOWNLOADS)
  84.         if newmax != self.MAX:
  85.             self.MAX = newmax
  86.             self.startDownloads()
  87.         
  88.  
  89.     
  90.     def startDownloadsIdle(self):
  91.         if self.paused:
  92.             return None
  93.         
  94.         last_count = 0
  95.         while self.running_count < self.MAX and self.pending_count > 0 and self.pending_count != last_count:
  96.             last_count = self.pending_count
  97.             sorted = SortedList(pendingSort)
  98.             for feed in views.feeds:
  99.                 if self.is_auto:
  100.                     max_new = feed.getMaxNew()
  101.                     if max_new != 'unlimited' and max_new <= self.feed_new_count.get(feed, 0) + self.feed_running_count.get(feed, 0):
  102.                         continue
  103.                     
  104.                 
  105.                 if self.feed_pending_count.get(feed, 0) <= 0:
  106.                     continue
  107.                 
  108.                 sorted.append((feed, self.feed_running_count.get(feed, 0), self.feed_time.get(feed, datetime.min)))
  109.             
  110.             for feed, count, time in sorted:
  111.                 if self.is_auto:
  112.                     feed.startAutoDownload()
  113.                 else:
  114.                     feed.startManualDownload()
  115.                 self.feed_time[feed] = datetime.now()
  116.                 if self.running_count >= self.MAX:
  117.                     break
  118.                     continue
  119.             
  120.         self.dc = None
  121.  
  122.     
  123.     def startDownloads(self):
  124.         if self.dc or self.paused:
  125.             return None
  126.         
  127.         self.dc = eventloop.addIdle(self.startDownloadsIdle, 'Start Downloads')
  128.  
  129.     
  130.     def pendingOnAdd(self, obj, id):
  131.         feed = obj.getFeed()
  132.         self.pending_count = self.pending_count + 1
  133.         self.feed_pending_count[feed] = self.feed_pending_count.get(feed, 0) + 1
  134.         self.startDownloads()
  135.  
  136.     
  137.     def pendingOnRemove(self, obj, id):
  138.         feed = obj.getFeed()
  139.         self.pending_count = self.pending_count - 1
  140.         self.feed_pending_count[feed] = self.feed_pending_count.get(feed, 0) - 1
  141.  
  142.     
  143.     def runningOnAdd(self, obj, id):
  144.         feed = obj.getFeed()
  145.         self.running_count = self.running_count + 1
  146.         self.feed_running_count[feed] = self.feed_running_count.get(feed, 0) + 1
  147.  
  148.     
  149.     def runningOnRemove(self, obj, id):
  150.         feed = obj.getFeed()
  151.         self.running_count = self.running_count - 1
  152.         self.feed_running_count[feed] = self.feed_running_count.get(feed, 0) - 1
  153.         self.startDownloads()
  154.  
  155.     
  156.     def newOnAdd(self, obj, id):
  157.         feed = obj.getFeed()
  158.         self.new_count = self.new_count + 1
  159.         self.feed_new_count[feed] = self.feed_new_count.get(feed, 0) + 1
  160.  
  161.     
  162.     def newOnRemove(self, obj, id):
  163.         feed = obj.getFeed()
  164.         self.new_count = self.new_count - 1
  165.         self.feed_new_count[feed] = self.feed_new_count.get(feed, 0) - 1
  166.         self.startDownloads()
  167.  
  168.     
  169.     def pause(self):
  170.         if self.dc:
  171.             self.dc.cancel()
  172.             self.dc = None
  173.         
  174.         self.paused = True
  175.  
  176.     
  177.     def resume(self):
  178.         if self.paused:
  179.             self.paused = False
  180.             eventloop.addTimeout(5, self.startDownloads, 'delayed start downloads')
  181.         
  182.  
  183.  
  184. manualDownloader = None
  185. autoDownloader = None
  186.  
  187. def startDownloader():
  188.     global manualDownloader, autoDownloader
  189.     manualDownloader = Downloader(False)
  190.     autoDownloader = Downloader(True)
  191.  
  192.  
  193. def pauseDownloader():
  194.     manualDownloader.pause()
  195.     autoDownloader.pause()
  196.  
  197.  
  198. def resumeDownloader():
  199.     manualDownloader.resume()
  200.     autoDownloader.resume()
  201.  
  202.  
  203. def _updatePrefs(key, value):
  204.     if key == prefs.DOWNLOADS_TARGET.key:
  205.         autoDownloader.updateMAX()
  206.     elif key == prefs.MAX_MANUAL_DOWNLOADS.key:
  207.         manualDownloader.updateMAX()
  208.     
  209.  
  210. config.addChangeCallback(_updatePrefs)
  211.